C语言实现迷宫求解

最近做了一个用C语言迷宫求解的题目，来分享一下。

题目要求：//迷宫的布局放入到一个二维的数组中 1代表该地方走不通为墙，0代表该地方可以走通，打印出来走的顺序
 //0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9
const int mizu[10][10] = {      1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1,  //0
 1 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 1,  //1
 1 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 1,  //2
 1 , 0 , 0 , 0 , 0 , 1 , 1 , 0 , 0 , 1,  //3
 1 , 0 , 1 , 1 , 1 , 0 , 0 , 0 , 0 , 1,  //4
 1 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 1,  //5
 1 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 1,  //6
   1 , 0 , 1 , 1 , 1 , 0 , 1 , 1 , 0 , 1,  //7
   1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1,  //8
   1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1  //9
} ;

分析：

1、可以利用C语言的栈来实现，起点坐标为（1,1），如果该步能走通，把该步的坐标入栈，且对该坐标进行标记，代表已经走过。

2、然后以该坐标（x，y）为中心进行，对该坐标的上(x,y-1)、右（x+1,y）、下(x,y-1)、左(x-1,y)的坐标顺时针进行判断可否走通（可否走通的条件为：该坐标的值为0，同时该步没有走过），寻找下一步坐标，如果找到了下一步，就接着入栈。

3、如果判断出来该坐标的四周的四个坐标（上、右、下、左）都不能够走通，则把该坐标出栈。

4、如果栈不空则接着往下找，如果栈空，则结束，没有可行的通路。

4、这样一直进行，找到出口坐标则结束，找到可行的通路

下面是我写的代码：有问题大家多交流。

#include <stdio.h>
#include <stdlib.h>

//迷宫的布局放入到一个二维的数组中 
						//0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9
const int mizu[10][10] = {1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1,  //0
						  1 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 1,  //1
						  1 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 1,  //2
						  1 , 0 , 0 , 0 , 0 , 1 , 1 , 0 , 0 , 1,  //3
						  1 , 0 , 1 , 1 , 1 , 0 , 0 , 0 , 0 , 1,  //4
						  1 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 1,  //5
						  1 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 1,  //6
					   	  1 , 0 , 1 , 1 , 1 , 0 , 1 , 1 , 0 , 1,  //7
					   	  1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1,  //8
					   	  1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1  //9
						} ;
int flag[10][10] = {0} ;						
typedef int TypeData ;
typedef struct node{
	TypeData datax ;
	TypeData datay ;
	struct node* next ;
}Node , *LinkList ; 

typedef struct stack{
	LinkList top ;
}STACK ;
//************************函数声明******************************
int stackInit(STACK* s ) ;
int pushStack(STACK* s ,TypeData x , TypeData y) ;
void popStack(STACK* s , TypeData* x , TypeData* y) ;
int isStackEmpty(STACK* s) ;
int mizePath(STACK* s ,TypeData end_x , TypeData end_y ) ;
int passMizu(TypeData x , TypeData y ) ;
//********************************************************** 

//链栈的初始化 
int stackInit(STACK* s )
{
	LinkList p = (LinkList)malloc(sizeof(Node)) ;
	if(!p)   return -1 ;
	p->next = NULL ;
	p->datax = -1 ;  
	p->datay = -1 ;
	s->top = p ;
	return 1 ;
}
//入栈操作
int pushStack(STACK* s ,TypeData x , TypeData y)
{
	LinkList p = (LinkList)malloc(sizeof(Node)) ;
	if(!p)   return -1 ;  //分配内存失败
	p->datax = x ;
	p->datay = y ;
	p->next = s->top ;
	s->top = p ; 
	return 1 ;
} 
//出栈的操作
void popStack(STACK* s , TypeData* x , TypeData* y)
{
	LinkList p = s->top ;
	s->top = p->next ;
	(*x) = p->datax ;
	(*y) = p->datay ;
	free(p) ;
}
//判断栈是否为空 
//1 空  0 不空 
int isStackEmpty(STACK* s)
{
	if(s->top->datax == -1)  //栈空 
		return 1 ;
	return 0 ;	
}
//找到最佳路径
//end_x , end_y为结束的坐标
//上 、右、下、左寻找方式 
int mizePath(STACK* s ,TypeData end_x , TypeData end_y ) 
{
	pushStack(s , 1 ,1) ; //初始坐标压栈 
	TypeData nowx = 1 , nowy = 1 ; 
	flag[nowx][nowy] = 1 ;  //该坐标已经被占用不能再通过 
	while(!isStackEmpty(s)) //当栈不空的时候 
	{
		if((nowx == end_x)&&(nowy == end_y))
		{
			return 1 ;
		} 
//		printf("nowx = %d  nowy = %d\n",nowx , nowy) ; 
//		system("PAUSE") ;
		if(passMizu(nowx , nowy-1))   //先向上寻找
		{
			nowy = nowy - 1 ; //坐标更改 
			pushStack(s , nowx , nowy) ;  //把该坐标压栈
		 	flag[nowy][nowx] = 1 ;  //该坐标已经被占用不能再通过
		}
		else  if(passMizu(nowx+1 , nowy)) //向右寻找		 
		{
			nowx = nowx + 1 ; 
			pushStack(s , nowx , nowy) ;  //把该坐标压栈
			flag[nowy][nowx] = 1 ;  //该坐标已经被占用不能再通过
		} 
		else if(passMizu(nowx , nowy+1)) //向下寻找 
		{
			nowy = nowy + 1 ; 
			pushStack(s , nowx , nowy) ;  //把该坐标压栈
			flag[nowy][nowx] = 1 ;  //该坐标已经被占用不能再通过
		}
		else if(passMizu(nowx-1 , nowy)) //向左寻找 
		{
			nowx = nowx - 1 ; 
			pushStack(s , nowx , nowy) ;  //把该坐标压栈
			flag[nowy][nowx] = 1 ;  //该坐标已经被占用不能再通过
		}
		else  //都行不通 
		{
			popStack(s , &nowx , &nowy) ;
		}
			
	} //while(!isStackEmpty(s)) //当栈不空的时候 
	return 0 ;
}
//判断该位置是否可通 
int passMizu(TypeData x , TypeData y )
{
	if((x > 9)||(y > 9))
		return 0 ;  //越界不可通
	if(mizu[y][x]) 
		return 0 ;  //该位置是墙，不可通
	if(flag[y][x])   
		return 0 ;  //该坐标已经被占用，不能通过 
	return 1 ;			 
}
//打印栈中的数据 
int printStackData(STACK s)
{
	STACK temp ;  //新建一个临时的栈 
	stackInit(&temp) ;
	if(s.top->datax == -1)  return 0 ; //栈为空 
	while(s.top->datax != -1)
	{
		pushStack(&temp,s.top->datax,s.top->datay);
		s.top = s.top->next ;
	}
	while(temp.top->datax != -1)
	{
		printf("(%d,%d)\n",temp.top->datax , temp.top->datay) ;
		temp.top = temp.top->next ;
	} 
	return 1 ;
}
int main()
{
	STACK mi_stack ; 
	int i = 0 , j = 0 ;
	stackInit(&mi_stack) ;
	
	if(mizePath(&mi_stack , 8 , 8))
	{
		printStackData(mi_stack) ; //把坐标倒叙打印出来 
	}	
	else printf("没有通路！\n") ; 
	
	return  0 ;
}